//import java.util.HashMap;
//
//class Solution {
//    public boolean canFinish(int numCourses, int[][] prerequisites) {
//        int[] in=new int[numCourses];
//        HashMap<Integer,List<Integer>> hash=new HashMap<>();
//        for(int i=0;i<prerequisites.length;i++){
//            int a=prerequisites[i][0];
//            int b=prerequisites[i][1];
//            List<Integer> list=hash.getOrDefault(b,new ArrayList<Integer>());
//            list.add(a);
//            hash.put(b,list);
//            in[a]++;
//        }
//
//
//        return bfs(hash,in);
//
//
//    }
//
//    private boolean bfs( HashMap<Integer,List<Integer>> hash,int[] in){
//        int i=0,count=0;
//        Queue<Integer> q=new LinkedList<>();
//        for(i=0;i<in.length;i++){
//            if(in[i]==0) q.add(i);
//        }
//
//        HashMap t=new HashMap();
//
//
//
//        while(!q.isEmpty()){
//            int cur=q.poll();
//            List<Integer> list=hash.get(cur);
//
//
//            if(++count==in.length) return true;
//            if(list!=null)
//                for(int j:list){
//                    if(--in[j]==0) q.add(j);
//                }
//
//        }
//        return false;
//
//    }
//}


import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class Solution {

    public String alienOrder(String[] words) {
        HashMap<Character,List<Character>> hash=new HashMap<>();
        HashMap<Character,Integer> in=new HashMap<>();
        for(int i=0;i<words.length;i++){
            char[] word=words[i].toCharArray();
            for(int j=i+1;j<words.length;j++){
                char[] word1=words[j].toCharArray();
                for(int k=0;k<word.length&&k<word1.length;k++){
                    if(word[k]!=word1[k]){
                        in.put(word1[k],in.getOrDefault(word1[k],0)+1);
                        hash.computeIfAbsent(word[k],a->new ArrayList<Character>()).add(word1[k]);
                    }
                }


            }
        }


        bfs();


    }


    public String bfs(HashMap<Character, List<Character>> hash, HashMap<Character,Integer> in){
        Queue<Character> q=new LinkedList<>();
        for(char c:in.keySet()){
            if(in.get(c)==0){
                q.add(c);
                in.get()
            }

        }
        StringBuffer s=new StringBuffer();

        while(!q.isEmpty()){
            char c=q.poll();
            List<Character> list=hash.get(c);
            s.append(c);
            for(char c1:list){
                in.put(c1,in.get(c1)-1)
                if(in.get(c1)==0) q.add(c1);
            }

        }

        for(char c:in.keySet()){
            if(in.get(c)!=0) return "";
        }

        return s.toString();

    }


}